Unified operating system for distributed computing

ABSTRACT

In some embodiments, a real-time event is detected and context is determined based on the real-time event. An application model is fetched based on the context and meta-data associated with the real-time event, the application model referencing a micro-function and including pre-condition and post-condition descriptors. A graph is constructed based on the micro-function. The micro-function is transformed into micro-capabilities by determining a computing resource for execution of a micro-capability by matching pre-conditions and post-conditions of the micro-capability, and enabling execution and configuration of the micro-capability on the computing resource by providing access in a target environment to an API capable of calling the micro-capability to configure and execute the micro-capability. A request is received from the target environment to execute and configure the micro-capability on the computing resource. The micro-capability is executed and configured on the computing resource, and an output of the micro-capability is provided to the target environment.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present application is a continuation of U.S. patent application Ser. No. 16/565,324 filed Sep. 9, 2019 and entitled “UNIFIED OPERATING SYSTEM FOR DISTRIBUTED COMPUTING,” which is a continuation of U.S. patent application Ser. No. 15/839,786 filed Dec. 12, 2017 and entitled “UNIFIED OPERATING SYSTEM FOR DISTRIBUTED COMPUTING,” now U.S. Pat. No. 10,452,361, which is a continuation of U.S. patent application Ser. No. 15/417,122 filed Jan. 26, 2017 and entitled “UNIFIED OPERATING SYSTEM FOR DISTRIBUTED COMPUTING,” now U.S. Pat. No. 9,841,955, which claims the benefit of U.S. Provisional Patent Application No. 62/287,201 filed Jan. 26, 2016 and entitled “UNIFIED OPERATING SYSTEM FOR DISTRIBUTED COMPUTING,” all of which are incorporated herein by reference.

Aspects of the current disclosure are related to U.S. Nonprovisional patent application Ser. No. 14/936,020, which was filed on 9 Nov. 2015, which is a continuation of U.S. Nonprovisional patent application Ser. No. 14/022,033, which was filed on 9 Sep. 2013, and which is a continuation of U.S. Nonprovisional patent application Ser. No. 12/698,361, which was filed on 2 Feb. 2010 and issued as U.S. Pat. No. 8,533,675 (included as Appendix A hereto) on 10 Sep. 2013, and which claims the benefit of U.S. Provisional Application No. 61/149,179, filed on 2 Feb. 2009, each of which is hereby incorporated by reference.

Aspects of the current disclosure also are related to U.S. Nonprovisional patent application Ser. No. 14/791,820, which was filed on 6 Jul. 2015, and which is a continuation of U.S. Nonprovisional patent application Ser. No. 13/846,630, which was filed on 18 Mar. 2013 and issued as U.S. Pat. No. 9,075,616 (included as Appendix B hereto) on 7 Jul. 2015, and which claims the benefit of U.S. Provisional Application No. 61/612,907, which was filed on 19 Mar. 2012, each of which is hereby incorporated by reference.

TECHNICAL FIELD

The present disclosure relates generally to operating systems, and more particularly, to a unified operating system for facilitating distributed computing.

BACKGROUND

Organizations may want to be agile so they may seize opportunities, respond to threats, and generally self-improve. The ability to adapt behavior for a current context is a fundamental optimization and survival strategy. Organizations that fail to evolve with their environment are not sustainable over time.

Advances in technology (e.g. The Web, The Cloud, and now the Internet of Things) have been transforming the environment for modern organizations. A radical reduction in the cost and latency of global collaboration is enabling new business models (e.g. Netflix; Uber; Airbnb; Skype; etc.) and disrupting incumbents. Organizations that cannot adapt to this increasingly distributed and dynamic environment risk displacement.

A challenge for many organizations is that their existing information, communication and automation systems, in and of themselves, do not support this new mode of operations. While there exist innumerable software languages and technologies that satisfy a wide variety of requirements, a significant challenge is how to flexibly and dynamically connect people, information, systems and devices for a new class of ‘smart’ processes.

SUMMARY

Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to detect one or more real-time events and determine a context based on the one or more real-time events. An application model is fetched based on the context and meta-data associated with the one or more real-time events, the application model referencing one or more micro-functions, each micro-function being a declarative model of one or more atomic functions and including at least one pre-condition descriptor and at least one post-condition descriptor. A functional graph is constructed based on the one or more micro-functions of the application model. The one or more micro-functions are transformed into a plurality of micro-capabilities, each micro-capability of the plurality of micro-capabilities being capable of satisfying at least one pre-condition of the at least one pre-condition descriptor and at least one post-condition of the at least one post-condition descriptor, by determining at least one computing resource for execution of at least one of the plurality of micro-capabilities by matching pre-conditions of the at least one micro-capability of the plurality of micro-capabilities and matching post-conditions of the at least one micro-capability of the plurality of micro-capabilities; and enabling execution and configuration of the at least one micro-capability on the at least one computing resource by providing access in a target environment to an application program interface (API), the API capable of calling the at least one micro-capability to configure the at least one micro-capability on the at least one computing resource and execute the micro-capability on the at least one computing resource. A request is received to execute and configure the at least one micro-capability on the at least one computing resource from the target environment. The at least one micro-capability is executed and configured on the at least one computing resource, and an output of the at least one micro-capability is provided from the at least one computing resource to the target environment.

In some embodiments, the one or more real-time events include a real-time system request of the target environment. In related embodiments, the real-time system request indicates an application object in a header of the real-time system request, and the context includes an identifier indicating the application object. In related embodiments, the output of the at least one micro-capability from the at least one computing resource comprises a customized representation of the requested application object.

In some embodiments, the application model, the one or more micro-functions, the plurality of micro-capabilities, and the at least one computing resource are modeled from a root object defining base properties and capabilities.

In some embodiments, the systems, methods, and non-transitory computer readable media further comprise a plurality of computing resources, wherein the plurality of computing resources includes the at least one computing resource, the plurality of computing resources providing a virtualized pool of resources, each of the plurality of computing resources being a virtualized infrastructure, a physical infrastructure, or a software-controlled device.

In some embodiments, the plurality of computing resources are distributed across a multi-dimensional network of nodes connected by one or more links.

In some embodiments, the at least one computing resource includes one or more computing resource descriptors, the one or more computing resource descriptors including an API descriptor associated with the API. In related embodiments, the one or more computing resource descriptors comprise any of one or more local interfaces, local capabilities, local services, supporting services, and operating system kernels. In related embodiments, the one or more computing resource descriptors facilitate management of thread handling, resources, and memory spaces for the at least one computing resource much as an operating system performs for a singular virtual infrastructure unit, physical infrastructure unit, or software-controlled device.

Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to provide a solution for the dynamic design, construction, deployment, use, and modification of software applications on a plurality of computing resources that operate collaboratively and in parallel.

In various embodiments, the systems and methods described herein are based on a multi-paradigmatic design, bridging Metaprogramming, Functional Programming, Object Oriented Programming and Model-Driven Engineering concepts, which results in a real-time interaction-driven system that dynamically constructs the components it needs in a dataflow pipeline of virtual functions to resolve a specific system request as a contextually optimized service.

In some embodiments, applications are declarative models of requirements for desired software behavior(s), which reference, directly or indirectly, Micro-functions. The application “intent” is realized by a Software Agent, which processes a cascade of models to render concrete behavior. The Agent resolves references for Micro-functions and executes them as a dataflow pipeline of contextualized Micro-capabilities on dynamically provisioned and configured Computing Resources on a short-lived thread

Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to provide a federated computer system consisting of at least two computing devices and a logical and physical fabric.

In some embodiments, a system comprises a plurality of computing resources, each of which may be a tangible embodiment (e.g., a computing device) or a virtual embodiment of a group of a plurality of computing resources. The traits of these resources may be identified and made accessible through a classification scheme, providing unified access and usage of these resources independent of their embodiment.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a plurality of sets of small software elements, where each element embodies a single function without side effects, utilizing the resources of the underlying system embodiment through selective usage of identified traits as required for the function's embodiment. These small software elements may constitute contextualized micro-capabilities, which may be uniquely identified, and defined by their preconditions, post-conditions, and/or an embodied algorithm.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a plurality of sets of models and metamodels, which describe and define the interfaces and related semantics of all components of a system described herein. A metamodel may define a declarative language for the creation of a plurality of models describing the traits of the embodiment of the computing resources. These models may describe these traits in their structural aspects and in their exhibited semantics (e.g., application program interfaces (APIs)).

In some embodiments, a metamodel also may be used to define a language for the creation of a plurality of models, each of which may define the structural aspects and semantics (e.g., APIs) of a single micro-capability. The semantics defined by the model may include the algorithm embodied by the described micro-capability. Additionally, the semantics may include the preconditions that must be satisfied before invoking any execution of the algorithm embodied by the micro-capability. Preconditions may include the structure and type of any information required as input for the algorithm embodied by the micro-capability, any specific conditions of the surrounding environment required for the execution, and/or the like. These environment conditions may include all required supporting software and traits of the computing resource hosting the micro-capability embodiment. The model may further define the post-conditions holding after completion of the execution. Post-conditions may describe the structure and type of the execution results, their meaning, the specific conditions of the surrounding environment that must be met for a transfer of execution results and control flow, and/or the like.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide ways and means to organize micro-capabilities. Micro-capabilities may follow two principles demanded by the paradigms of Model-Driven Architecture® and Functional Programing. These principles are separation of concerns and an absence of side effects. With respect to micro-capabilities, this means that each micro-capability may implement a single, distinct and atomic algorithm. It may perform the execution of this algorithm exclusively on the basis of the prevailing preconditions at the moment of invocation and may deliver results only in the form specified by the post-conditions. Besides these results, the execution may have no further effects on the surrounding environment. The conditions may be modeled as a micro-function, an implementation-independent definition (e.g., an abstract definition), sufficient to describe and classify a plurality of equivalent micro-capability embodiments hosted on a plurality of computing resources. The cascade of models used by the system transforms the micro-function into a contextualized embodiment for each use. These embodiments of micro-capabilities may be organized in a plurality of collections, like repositories or libraries. However, the definition and classification of micro-capabilities may be singular and common for all their embodiments. This enables the classification of all micro-capabilities independent of their embodiment, and provides an ability to maintain the plurality of classifications definitions for all micro-capabilities in a common catalog structure. This catalog may afford an ability to automatically derive executable solutions from the plurality of micro-capabilities.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a methodology and embodiment to construct executable software applications from micro-capabilities. Applications may be modeled using a declarative modeling methodology and environment. Applications may be defined in structure and function by a declarative model. This model comprises a plurality of sets of models that describe functional elements of the application as referenced micro-functions. A platform-independent embodiment (e.g., an abstract embodiment) of the application may then be constructed by assembling a solution graph from micro-function definitions based on algorithms and pre- and post-conditions. A software agent may perform a recursive transformation and combination of contextualized micro-capabilities. The result may be a complete core application, however in a representative (e.g., abstract) form, which means there is yet no real and executable embodiment of the application, but a complete composition plan listing all required micro-capabilities and their combination. After deciding the deployment target, the agent may retrieve the micro-capability embodiments built for and compatible with the traits of the execution environment and construct the application embodiment based on the composition plan (e.g., an abstract composition plan). The composition plan may provide a real-time system by deploying and executing the software as a dataflow pipeline of contextualized Micro-capabilities on dynamically provisioned and configured Computing Resources in a short-lived thread. Or, since the composition plan is completely platform-independent, it may be pre-calculated and stored, and then reused for a plurality of deployments on a plurality of target platforms.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to extend the technology presented herein into a federation over a plurality of computing resource embodiments distributed across a multi-dimensional arrangement of nodes. These nodes may represent physically separated embodiments of one or more computing resources, or may represent isolated logical computing resources within a larger hosting environment. An example for the latter would be a typical datacenter arrangement, where a plurality of virtual servers is hosted by a single physical server system. Each embodiment of a computing resource may represent an autonomous, self-contained system, connected to the plurality of surrounding computing resource embodiments by the means of a communication facility. These embodiments may expect this communication facility to provide a standardized set of peer-to-peer communication services for synchronous, asynchronous and ad-hoc messaging. The underlying technology to realize these services may vary from case to case. The plurality of interconnected computing resources allows applications to include models for Distributed Operating System concerns including, but not limited to, thread handling, resource management, memory spaces, and/or the like.

In some embodiments, a fabric of interconnected computing resources may be described as nodes, interconnected by links. Each node may host a complete embodiment of an execution environment capable of executing applications constructed from an arrangement of micro-capabilities. However, not all nodes need to have the ability to perform the construction process, or require this ability. This distinction allows the inclusion of nodes with very limited resources into the federated arrangement without losing the benefits of the model-driven automated composition of applications. The minimum abilities from such a limited, or basic node may include: (1) the presence of an execution environment that supports the execution of an application composed from micro-capabilities without relying on resources outside of that node; (2) the ability to report the traits and state of this node to other nodes; (3) the ability to receive and/or replace complete applications and/or individual micro-capabilities, communicated to that node by other nodes that are part of the fabric; (4) the ability to initialize, start, stop, reset, delete, or otherwise influence loaded applications based on communications received from other nodes in the fabric; and/or the like. In an embodiment, there must be at least one node in the fabric of nodes that has extended abilities beyond the abilities of a basic node, however, there is no upper limit on the plurality of such extended nodes.

In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a method of a rigorous structural and semantic description of APIs for all micro-functions and micro-capabilities. Based on this, an automated selection, matching and combination of micro-capabilities may be provided. This may be accomplished on the model level and therefor independent of the embodiment.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an architecture of a computing resource according to an embodiment.

FIGS. 2A, 2B and 2C show illustrative variations of an extended architecture pattern according to embodiments.

FIG. 3 shows illustrative interconnected nodes according to an embodiment.

FIG. 4 shows an illustrative micro-capability meta-architecture according to an embodiment.

FIGS. 5A, 5B and 5C show illustrative aspects of micro-capabilities according to embodiments.

FIG. 6 shows an illustrative construction of an application model according to an embodiment.

FIG. 7 shows an illustrative distributed environment according to an embodiment.

FIG. 8 shows an illustrative process for selecting and chaining micro-capabilities according to an embodiment.

FIG. 9 shows an illustrative process of deployment and configuration of micro-capability-based applications according to an embodiment.

FIG. 10 shows an illustrative environment for developing a functional model-based application according to an embodiment.

DETAILED DESCRIPTION

Applications are already rapidly evolving from centrally defined and controlled ‘monoliths’ to composite applications of Services and APIs that need to cross silos, organizational boundaries, domains, protocols and technologies. However, the prevailing application development practice is to develop software solutions on top of discrete software components required to process functional requirements (i.e. “middleware”), which results in siloed, static and brittle solutions. Middleware software components (e.g. Enterprise Service Buses; Business Process Management Suites; Complex Event Processing software; Business Rules Management Systems; API Gateways; Integration Technologies; Business Intelligence tools; etc.); are pre-integrated to form a middleware “stack”. Each component generally represents a long-running synchronous process, waiting for inputs to perform transformations and output results (i.e. operations). Since all connections between applications and components, components and components, and components and their underlying infrastructure (i.e. compute, storage and network resources) are established a priori creating a tangle of fixed dependencies (i.e. “tight-coupling”), any change to this solution architecture may cause applications to fail to perform desired target behavior. In addition, this design is based on a linear series of message-passing for communicating application state between component processes with the output of one component being the input to the next component, for an ordered series of operations (i.e. “orchestration”), which ultimately results in the targeted application behavior. The middleware stack introduces its own collective overhead, which impacts development considerations regarding compute and input-output intensive applications. The linear message-passing does not lend itself to a broad real-time evaluation of application state making it more ‘expensive’ from a processing perspective to dynamically customize application behavior per interaction (e.g. personalize user-experience; optimize transaction; etc.). Also, since application state related to executing functions is distributed across components, if any component process (i.e. executing thread) fails, state can be lost, leading to a failed transaction with no direct compensations. As a result of these inherent limitations, the prevailing application development practice involving middleware components is a rate-limiter on emerging business requirements, business agility writ-large and the transformation of modern companies into digital businesses.

In middleware software development, adaptations are traditionally accomplished through a directed and comparably slow process, constrained by the nature of the organizations and their systems. To date, exception and change management still generally remain inefficient, disconnected and largely manual processes.

Traditional engineering approaches are not necessarily capable of supporting rapid and dynamic adaptation of software systems in the dimensions of structure, functionality and spatial federation. The common practice of specifying and creating technical systems as a whole consists in the majority of cases of a single process stream, which typically leads to products forming large, cohesive units, with their characteristics “cast in stone” at a very early stage. This approach may be suitable for long-lasting infrastructure projects, like bridges or buildings, but not for information technology. However, to date, a similar single-stream process is a quite common practice in software engineering too, where it becomes more and more inappropriate, as it results in monolithic products that are difficult to maintain or change, and impossible to prove for correctness.

Many approaches have been proposed over the past decade to change this and make the development process in software engineering, or information technology in general, more agile and adaptable. A promising methodology among those is the Model-Driven Architecture® (MDA®) proposed by the Object Management Group® (OMG®). This methodology prescribes a cascade of modeling activities as the principle design phase for a system. The cascade starts with a high-level and conceptual model (e.g., abstract conceptual model), derived as a response to, and fulfillment of the system requirements. In the MDA® methodology, a sequence of model transformations follows that transition step-by-step from the conceptual model towards one or more implementable platform-specific models (PSM). During this cascade of model transformations and extensions, more and more external information is introduced to convert the concept into implementable specifications. While the pure and literal application of the MDA® methodology provides ample opportunity for change and verification along that cascade of model transformations and refinements, it still generally results in a monolithic end product. Though derived through a model-based and flexible design phase, a PSM implementation is itself a static output (i.e. the PSM is compiled to a non-portable, non-dynamic, non-adaptive, non-evolutionary platform).

Solution Overview

Changes in the way we work may require us to re-think application architecture and the middle-tier. The conventional middleware stack is being disrupted by the broader technology movements mentioned above. Successful organizations are complex adaptive systems. In some embodiments, organizational systems support a complex adaptive operation, which is capable of adapting to a changing environment through dynamic networks of interactions and individual and collective behaviors that mutate and self-organize in response to changes and events to increase an agility and sustainability of the organization.

In some embodiments, the middle-tier is a lightweight, horizontally-architected, elastically scalable layer between the end-points an organization has access to and the behavior it wants (i.e. application logic). In this manner, middleware is re-imagined as a virtualized software-defined server with a distributed operating system, which supports the composition, run-time and management of highly responsive, connected and adaptive applications with related middleware functionality realized as dynamic services, rather than discrete software components.

Re-conceptualization of the middle-tier as a virtual software-defined server with a distributed operating system may allow organizations to more naturally express themselves as complex adaptive systems.

Adaptation, as it relates to the new middle-tier may include an ability to handle each system interaction individually, as its own dynamically interpreted complex-event, in order to construct a custom policy-controlled response based on real-time operational intelligence. Instead of deploying processes that simply execute fixed models for standardized responses from static connections, a fully dynamic “situationally-aware” approach may natively support variance at the model level to personalize user-experiences, contextualize policy-enforcement, recommend or direct next-best-actions (e.g., logical workflow), and/or the like, while at the metamodel level using interaction-metadata to translate policies that drive the discovery and binding of just the relevant system objects to resolve and record the event.

An ability to support variance at the model level affords the potential for in-flight user-driven policy-constrained modifications for a single instance without disruptive exception management processes. Likewise, an ability to support variance at the metamodel level affords the potential for adaptation of any of the participating system objects, without disruptive change management processes, as the objects, or even specific versions of each object, may be found and/or bound in real-time (e.g., dynamic composition and automated interoperability for non-disruptive API evolution).

A flexible and adaptable middle-tier may be extended by queries, functions, predictive analytics machine-learning algorithms, and/or the like, which may be other endpoints that may be referenced at either the model or metamodel level.

In an embodiment, the MDA® methodology is combined with principles from Functional Programming, Functional Reactive Programming, Dataflow Programming, Metaprogramming, and the like, in a multi-paradigmatic solution. Such a combination makes a new approach explicit: instead of producing a monolithic application as specified by the PSM, build a functional equivalent application as an arrangement of lightweight functional units. These functional units may conform to functional elements found in the conceptual model or one of its early derivatives in the model cascade. Each such functional unit may implement exactly one function without further side-effects and/or conform to a common interface specification. From the perspective of Functional Decomposition, this embodiment includes, but is not limited to, functions, business entities, policies, services, applications, and/or the like, that are all described by metadata in a common pool. Interactions of this embodiment may take the form of functional chains configured by metadata as directed by models. Essentially, this may satisfy the criteria for the “Pipe-and-Filter” architectural pattern, which is also part of the REST architectural style. From a system perspective, these functional chains include, but are not limited to, system functions that perform middleware capabilities, system policies for non-functional concerns, and/or the like, that are assembled from the functional units as part of the model cascade.

Collectively, these high-level principles may be brought together in a solution that constructs the components it needs in a pipeline of virtual functions or “micro-capabilities” that exist ephemerally to resolve a specific request as a dynamically realized service. This stands in stark contrast to the current middleware stack paradigm of manually integrating purpose-built static components, and then writing static applications across them that are inherently tightly-coupled and brittle, inhibiting desired organizational agility.

Building an application as an arrangement of functional units may open up the application for change (by altering the arrangement and/or substituting functional units with alternatives), but also may provide a basis for spatial extensions. Functional units belonging to one application may be placed on alternative processing facilities, thus allowing for spatial distributed and potentially parallel execution.

While modeling is an approach to specify the desired product in various level of abstraction, meta-modeling may provide a capability to define the modeling language used to specify the product, and to specify all aspects of the production environment used to create and deploy the product, as a set of models. As a consequence, the production environment itself opens up for easy adaptation, which in turn provides yet another dimension of adaptability to the final product. Using a common approach for modeling and meta-modeling, the boundary between “design-time” and “run-time” may be allowed to vanish. Well-defined algorithms and methodologies exist to select functional units and to support construction of an arrangement representing the application.

By applying Meta-modeling concepts to MDA®, some embodiments are able to interpret models based on real-time interaction context, using a dataflow pipeline to perform transformations on-demand, resulting in declarative and dynamic solutions, this is contrast to traditional applications of MDA® for solution development where models are compiled in advance creating specific source to target transformations a priori, resulting in imperative and static programs.

In some embodiments, all elements and components of the system, including, but not limited to, Applications, Micro-functions, Micro-capabilities, Computing Resources, and the like, are modeled from a Root Object that defines base properties and capabilities (e.g. identifier, metadata descriptor, etc.). The cascade of models used to generate applications may provide a form of dataflow-based polymorphic inheritance, contextualizing all models from a common base-object, allowing the application of Object Oriented Design Patterns (e.g. Façade, Factory, etc.) to assembled Functional Programs.

Solution Components

Solution components, according to some embodiments, may be defined as follows:

Applications are declarative models of requirements for desired software behavior(s), which reference, directly or indirectly, Micro-functions. Application “intent” is realized by a Software Agent, which processes a cascade of models to render concrete behavior. An embodiment of Application is described below.

Micro-functions are declarative models of atomic functions, side-effect free and independent of implementations that are consumed by Applications. Micro-functions are explicitly modeled. Micro-functions are transformed into contextualized Micro-capabilities during execution. An embodiment of Micro-functions is described below.

Micro-capabilities are ephemeral processing intermediaries that are dynamically constructed by the Software Agent when implementing a Micro-function as a component of a solution. An embodiment of Micro-capabilities is described below

Computing Resources are declarative models of infrastructure resources (i.e. virtual and tangible compute, storage and network nodes, centralized and distributed), which collectively present a hybrid distributed network as a unified pool of resources (i.e. a computational mesh, lattice, fabric, etc.). An embodiment of Computing Resources is described below.

A Software Agent is a proxy for the System, handling requests and interpreting the Declarative language in order to process the cascade of models to realize intended application behavior. Software Agents dynamically construct, alter and adapt applications in real-time, by rearranging and reconfiguring micro-capabilities based on changes in any of the models (or objects they represent). Such behavior would not be possible using traditional model-driven approached.

In some embodiments, a Software Agent is an application realized by a recursive process:

-   -   a. Software Agent identifies “intent” by fetching an application         model     -   b. Constructs a corresponding functional graph based on         referenced Micro-functions     -   c. Transforms Micro-functions into contextualized         Micro-capabilities, capable of satisfying the pre-conditions,         post-conditions and functional characteristics of each         Micro-function by:         -   i. Determines appropriate Computing Resource for execution             of the Micro-capability by matching pre-conditions,             post-conditions and functional characteristics between their             respective descriptors         -   ii. Uses generated API descriptors for the Computing             Resource to execute, deploy, connect or configure it as             required by the Micro-capability         -   iii. Executes the configured Micro-capability on the             Computing Resource     -   d. Updates the process, chaining Micro-capabilities:         -   i. Using generated API descriptors to connect             Micro-capabilities     -   e. Recursively evaluates and chains Micro-capabilities,         repeating chain until the “intent” is met.

Other Embodiments of Software Agents are described below.

Computing Resource

In some embodiments, all applications, end-user and system applications, may utilize a logically uniform computing resource to host their execution. FIG. 1 shows an architecture of a computing resource according to an embodiment. Independent from the actual embodiment, each Computing_Resource 110 may exhibit a uniform interface and a well-known set of services, divided into two categories: Local interfaces and services, represented by the Traits_Abstraction 130, and federation-related communication and remote access or invocation services provided by the Federation_Fabric_Endpoint 120. This plurality of interfaces and services may form a fixed and stable contract Computing_Resources provide, regardless of how they are embodied.

Traits are a relatively new concept, originally introduced in conjunction with the C++ meta-programming concept, but are now an intrinsic part of the latest generation of programing languages, like Scala, Swift, and others. Conceptually, traits are very similar to interfaces in that they provide a contract consisting of declarations for data structures and operations, but in contrast to regular interfaces, traits may also directly embody implementations for data structures and operations.

Computing_Resources require the incorporation of traditional operating system functionality to fulfill their service contract. The following discussion extends the architecture pattern introduced in FIG. 1 by adding an operating system component and a platform support component. Three illustrative common variations of that extended architecture pattern are discussed in conjunction with FIGS. 2A, 2B and 2C. However the plurality of variations is not limited to the shown three variants. Other variants may include, but are not limited to, nodes providing storage capabilities, networking capabilities and/or the like. To this extent, any variant fitting the pattern is implicitly included.

FIG. 2A shows core operating system support required by the Computing_Resource 110 may be provided through inclusion of a Dedicated_MicroKernel 221 into the Traits_Abstraction 130. Microkernels may provide only very basic operating system services, only those requiring a privileged and protected execution environment. All other operating system services may be expected by the microkernel to be provided by processes operating in unprivileged space (often referred to as “servers”). The plurality of these services may be aggregated into the Platform_Support component 210 of the extended Computing_Resource architecture pattern.

In an illustrative more “traditional” operating system environment, shown in FIG. 2B, the OperatingSystem_Kernel 222 may provide a much richer service set out of its privileged execution environment than a microkernel. As a consequence, the Platform_Support component 210 may become more lightweight.

A third example variation for an extension of the basic architecture pattern, as shown in FIG. 2C, addresses virtualization. A fundamental concept of virtualization is to host a plurality of “guest” operating environments on a single “host” platform including the system's hardware and core operating system services. In this discussion, the “host” part of virtualization is not explicitly discussed and each “guest” system may be treated as an independent Computing_Resource.

In FIG. 2C, a Virtualization_Kernel 223 takes the position of the operating system component. The form and “shape” of this kernel may vary widely dependent on the virtualization technique used.

Common (in architecture terms) to the three illustrative architectural alternatives presented in FIGS. 2A, 2B and 2C is the Platform_Support component 210. An embodiment of this component may be different for any internal architecture variant of the Traits_Abstraction 130, as depicted in FIGS. 2A to 2C. The Platform_Support component 210 may provide a bridge between the provided features and interfaces of the operating system component 221, 222 and 223 and the fixed interface contract promised by the Traits_Abstraction 130.

Federation Fabric

A feature of an embodiment is the arrangement of Computing_Resources 110 as a federated and distributed computing environment. Two nodes are shown in FIG. 3 as a representation of a plurality of interconnected Computing_Resource nodes with no conceptual upper limit of the number of nodes forming this plurality. Collectively a set of interconnected Computing_Resource nodes provides a unified pool of resources (i.e. a computational mesh, lattice, fabric, etc.). This unified pool allows applications to include models for Distributed Operating System concerns including, but not limited to, thread handling, resource management, memory spaces, and/or the like.

Two nodes may be connected by means of a physical connectivity 320 between Federation_Fabric_Endpoints 120 embedded in the respective Computing_Resources 110. “Physical” in this context means any embodiment of a communication means capable of supporting a live peer-to-peer connection based on a standardized peer-to-peer communication protocol. This protocol requirement may exist only for the exhibited peer-to-peer connection; the underlying “physical” implementation may be free to use any reasonable means as long as the peer-to-peer requirements may be guaranteed and as long as embodiments of corresponding communication ports 310 compatible with both, the embodiment of the incorporating Federation_Fabric_Endpoint 120 and the characteristics of the “physical” connection scheme 320, are available.

The peer-to-peer connectivity across the communication path 320 may support the virtual direct connectivity between Computing_Resources 110 as shown as a dashed line 330 in FIG. 3 , as well as a virtual direct connection between Traits_Abstractions 130, as shown by dashed line 340.

MicroCapabilities

FIG. 4 introduces an illustrative micro-capability meta-architecture according to an embodiment. Micro-capabilities may be small functional units providing a single function without side effects. Micro-capabilities are ephemeral intermediaries for executing the function, constructed as part of the cascade of models forming a Model-driven pipeline. Applications and services may be subsequently composed by forming arrangements of micro-capabilities. This process is model-based and model-driven. FIG. 4 outlines an illustrative three-level meta-architecture for micro-capabilities.

The modeling language for all micro-capabilities may be defined by the micro-capability meta-component named MicroCapability 400, which is part of a metamodel according to an embodiment. The meta-component MicroCapability may be a logical blueprint for the modeling of a plurality of function micro-capabilities, of which three are shown as examples for the whole plurality 411, 412, 413. The fact that the meta-component MicroCapability may be a defining metamodel for those Function micro-capabilities is expressed by the dependency relationships 430, stereotyped as «definedBy».

Each of the functional micro-capability (component models) may be embodied by at least one, or a plurality, of micro-capability implementations, embodying the algorithm, preconditions, and post-conditions specified in the corresponding micro-capability model. This is shown example by items 421, 422, 423, 424 and 425. An instantiation relationship is shown as dependency 440 stereotyped «instantiates». Each modeled micro-capability, as for example Function1 411, may be instantiated by a plurality of sets of micro-capability instances. These sets may span a two dimensional space, where variations in the embodiment of the concrete algorithm implementing the abstract algorithm defined by the modeled micro-capability component (Function1 in this example) may represent one dimension, and the dependency of the micro-capability embodiment on the plurality of possible embodiments of the target Computing_Resource 110 may represent another dimension.

FIG. 5A shows an example expanded view of the metamodel provided by a meta-component MicroCapability 400 according to an embodiment. It shows an illustrative definition of the provided interface 501, which may expose the means and conditions to invoke the function provided by the MicroCapability; and an illustrative definition of the required interface 502 that may provide the processing results. Any receiving entity has to match this required interface in order to receive the function results correctly.

The MicroCapability Descriptor 510 may define an information model holding classification keys and formal descriptors about the functional characteristics and properties of the MicroCapability. This information may be complemented by an API_Descriptor 511, which may define the information model describing the provided and required interfaces, and all associated pre- and post-conditions. Dependency 503 may refer to the provided API 501 (and related post-conditions), while Dependency 504 may refer to the required API 502 and related post-conditions. When a micro-capability is modeled based on this metamodel, the MicroCapability Descriptor and API_Descriptor may be instantiated. Their embodiment may hold all necessary information to create, combine and deploy an embodiment of that modeled micro-capability.

FIG. 5B shows an example arrangement of three modeled micro-capabilities, Function1 411, Function2 412 and Function3 413 according to an embodiment. These micro-capabilities may be fully described by their corresponding embodiments of MicroCapability Descriptors with names corresponding to the type name of the modeled micro-capability they describe. These are shown as 531 for Function1, 532 for Function2, and 533 for Function3. Connecting interfaces may be described by two descriptors, one for the provided interface of the downstream micro-capability and one for the required interface of the upstream micro-capability. These two interfaces may match to allow a connection. The pairing of provided and required interfaces, shown as 521, may provide the connectivity between micro-capability Function1 411 and micro-capability Function2 412. Correspondingly, embodiments of API_Descriptors may describe the details of this interface pairing 521. Part of API_Descriptor 541 may describe the required interface of micro-capability Function1 411, and part of API_Descriptor 542 may describe the matching provided interface of micro-capability Function2 412.

An equivalent arrangement may exist for the interface pairing 522 between micro-capability Function2 412 and micro-capability Function3 413, using part of API_Descriptor 542 to describe the required interface of micro-capability Function2 412, and part of API_Descriptor 543 to describe the matching provided interface of micro-capability Function3 413.

FIG. 5C shows illustrative embodiments of MicroCapability Descriptors and owned API_Descriptors, which may be stored as part of the MicroCapability metadata repository. The plurality of descriptors may comprise elements of an ontology and form a searchable catalog of platform-independent micro-capability metadata, which may be used by the Composer Agent 720 in FIG. 7 (e.g., an agent configured to perform a composer role) to construct arrangements of interface-compatible micro-capabilities, which in their totality may implement the desired application functionality.

Application Construction

An example construction of an Application model 600 is shown in FIG. 6 by incorporating and combining the models of three micro-capabilities, Function1 411, Function2 412 and Function3 413. Two Application embodiments, app1 641 and app2 642 may be constructed and deployed into an embodiment of a Computing_Resource named node1 610. The construction and deployment act is symbolized by the pair of dependency relationships stereotyped «instantiates» 650. These example embodiments of the micro-capabilities to be incorporated into the Application embodiments, following the Application model 600, may be received from the MicroCapability implementation repository 620, which can hold a set of anonymous embodiments of micro-capabilities, as shown by 631, 632, 633 and 634. Copies of these may be incorporated into the Application embodiments and named accordingly.

This example is shown by 421, 423 and 425 for app1 641, and by 422, 423 and 424 for app2 642. The fact that these Application embodiments 641, 642 may be composed from micro-capability embodiments stored in the MicroCapability implementation repository 620 is expressed by the dependency relationships stereotyped «composedFrom» 660.

The MicroCapability implementation repository 620 may only logically be part of the Computing_Resource embodiment node1 610. In this example, the embodiment of repository 620 may be collocated with another Computing_Resource embodiment and connected with the current Computing_Resource embodiment node1 610 by means of the peer-to-peer communication services provided by the Federation_Fabric_Endpoints 120.

Complete System Architecture

FIG. 7 shows an example distributed environment in some embodiments. FIG. 7 depicts an example chain of three Computing_Resources 110 connected by materialized communication links 320, which are linking the Federation_Fabric_Endpoints 120 through the communication ports 310 built into the Federation_Fabric_Endpoints. Virtual peer-to-peer communication between the Computing_Resources is shown as a dashed line 330. Likewise, virtual peer-to-peer communication between Traits Abstractions is shown as dashed line 340. These virtual peer-to-peer connections can be realized by the Federation_Fabric_Endpoints over their communication link 320.

The shown three Computing_Resources may differ only in the services associated with them. They may also differ in the method of their embodiment, but on a logical level, they may be equal, as guaranteed by a provided common service contract. The Computing_Resource shown in the center of FIG. 7 may host a complete system stack, comprising the MicroCapability implementation repository 620 and the related Deployer Agent 710 (e.g., an agent configured to perform a deployer role); the MicroCapability metadata repository 550 and the related Composer Agent 720 (e.g., an agent configured to perform a composer role); and the application development environment Design_Studio 730. The Design_Studio may incorporate an embodiment of the Metamodel repository 740 that can contain all definitions of any model element used within the system. The Design_Studio 730 may have associated private application model storage 733.

In some embodiments, the Computing_Resource shown to the left in FIG. 7 may represent a minimum configuration of a node within the federated computing environment described herein. In addition to the core Computing_Resource 110, it may embody the Deployer Agent 710, which may have control over the Computing_Resource through the connection 712, but receive embodiments of micro-capability functions through the virtual connection 713 to a closely located MicroCapability implementation repository 620. In various embodiments, this connection 713 may be realized through a communication connection hosted by the Federation_Fabric_Endpoints 120 and their materialized communication link 320. In some embodiments, the peer-to-peer protocol used by the Deployer Agent 710 to the MicroCapability implementation repository 620 may follow representational state transfer (REST) principles.

The Computing_Resource shown on the right side in FIG. 7 also may host a Deployer Agent 710, as well as its private embodiment of the MicroCapability implementation repository 620. This configuration demonstrates the federation abilities of the repository architecture described herein. While repositories, the Metamodel repository 740, the MicroCapability metadata repository 550 and the MicroCapability implementation repository 620 in their totality may represent one logical repository structured with multiple meta-levels, the embodiment may use federation and replication techniques to separate implementation concerns and to improve performance of the overall system by collocating information and processing units.

Composition, configuration, and deployment of applications may be accomplished by autonomous agents on two logical levels. On the platform-independent model level, the Composer Agent 720 may accept application models from the Design_Studio 730 via the model input interface shown as the connector 732. The Composer Agent 720 (e.g., an agent configured to perform the composer role) may analyze the application model and construct an equivalent model as a lattice of interconnected micro-capabilities, using the descriptors and ontologies provided by the MicroCapability metadata repository 550 via the connector 721. An illustrative embodiment of this process is detailed in the next section. A result of this processing by the Composer Agent 720 may be a new model that includes a deployment and configuration plan. This model may be communicated to the plurality of Deployer Agents 710 (e.g., agents configured to perform the deployer role) which may construct the embodiment of the application using the appropriate combination of compatible embodiments of micro-capabilities as provided in the plurality of MicroCapability implementation repositories 620 and as directed by the deployment model communicated through connection 722 from the Composer Agent 720 to the plurality of Deployer Agents 710. The Deployer Agents 710 may be responsible to load and activate the application in the appropriate Computing_Resources 110 through their connection 712.

Application Construction Process

FIG. 8 outlines an illustrative micro-capability selection and chaining process according to at least one embodiment. The process is entered at 800, retrieving the Behavior Specification from the application model in action 801. Action 802 derives a detailed Function Graph from the already function-oriented behavior model acquired in the previous action 801. The root of the Function Graph also may hold the Start Conditions of the application, a complex structure composed from invocation parameters, preconditions and the function's algorithm classification. In action 803, these Start Conditions are set as the seed conditions for a micro-capability search. This search may be performed as an iterative execution of the MicroCapability Selection Pattern detailed as 810. The Start Conditions may be matched against the ontology of MicroCapability Descriptors 510 and related API_Descriptors 511 in the MicroCapability metadata repository 550. This search is performed in action 811. Multiple matches are supported, which may have different quality of fulfillment of the Start Conditions but are all ontologically valid, for which the search algorithm intentionally produces a plurality of results. All results derived in action 811 can be evaluated and a qualitative metric of fulfillment (Behavior Metric) may be calculated in action 812. This search is repeated until the set of candidate micro-capabilities is determined to be exhausted in action 813. Based on the current Start Conditions, the best fitting micro-capability may be selected in action 814 and returned into the main process together with its associated Behavior Metric through the exit from the MicroCapability Selection Pattern sub-process at action 815.

The returned Behavior Metric may be evaluated against the function requirements in action 805 and the returned micro-capability can be either accepted or rejected. If it is rejected, Selection Criteria and Start Conditions may be altered and the search pattern restarted. If the returned micro-capability is accepted, then it can be chained to preceding micro-capabilities in action 806 and the Start Conditions updated. This iterative process is repeated until the whole Function Graph is satisfied. This decision is made in action 807. In action 808, the final Start conditions may be converted into Terminal Conditions, which reflect the final function results and associated post-conditions. The completed MicroCapability Composition Plan can be published for subsequent deployment through the Deployer Agents (e.g., agents configured to perform the deployer role).

Application Deployment Process

FIG. 9 shows an illustrative process of deployment and configuration of micro-capability-based applications according to at least one embodiment. After entering the process at 900, the Application Deployment Model may be retrieved by the Deployer Agent 710 (e.g., agent configured to perform the deployer role) in action 901. This model may include the MicroCapability Composition Plan and the model of the chained micro-capabilities as produced by the Composer Agent 720 (e.g., agent configured to perform the composer role) and described in previous section. The Deployer Agent 710 may require additional information about the set of Computing_Resource embodiments intended as deployment targets, which can be supplied in action 902. This leading Deployment Agent may contact the Deployment Agents associated with the Computing_Resource embodiments to retrieve the descriptors for each target Computing_Resource embodiments in action 903. In action 904, the leading Deployment Agent may calculate the actual Deployment Plan and communicate it to all involved target Deployment Agents. Each of the target Deployment Agents may evaluate independently if all required micro-capability embodiments (in a form compatible with the Computing_Resource embodiment) are available at the locus of the Computing_Resource embodiment 905. If this is not the case, then embodiments of all required micro-capabilities may be acquired by the target Deployment Agent through the communication facilities from the closest compatible micro-capability implementation repository 620 in action 906. This action may not be performed if all required embodiments of micro-capabilities are already present at the locus of the target Computing_Resource embodiment. Finally at action 907, the Deployer Agent associated with the target Computing_Resource embodiment performs the aggregation of micro-capability embodiments guided by the Deployment Plan and as explained herein.

This results in an executable application deployed into the target Computing_Resource embodiment at the exit action 908 of the deployment process.

Computing Environment

FIG. 10 shows an illustrative computing environment 1010 for managing (e.g., developing, executing, and/or the like) a functional model-based application 1036 according to some embodiments. As described herein, a user 1012 (e.g., an individual, group of individuals, computing device, group of computing devices, and/or the like), may utilize a computer system 1020 (e.g., a node) of the environment 1010 to develop, configure, deploy, and/or the like, a functional model-based application 1036. To this extent, the computer system 1020 may provide a functional modeling interface 1030, which can enable the user 1012 to define, modify, and/or the like, one or more aspects of the functional model-based application 1036 using any solution. Additionally, the computer system 1020 may include a distributed operating system 1032, which may enable execution of the functional model-based application 1036 on the computer system 1020.

The computer system 1020 is shown including a processing component 1022 (e.g., one or more processors), a storage component 1024 (e.g., a storage hierarchy), an input/output (I/O) component 1026 (e.g., one or more I/O interfaces and/or devices), and a communications pathway 1028. In general, the processing component 1022 executes program code, such as a functional modeling interface 1030, which is at least partially fixed in the storage component 1024. While executing program code, the processing component 1022 may process data, which can result in reading and/or writing transformed data from/to the storage component 1024 and/or the I/O component 1026 for further processing. The pathway 1028 provides a communications link between each of the components in the computer system 1020. The I/O component 1026 may comprise one or more human I/O devices, which enable a human user 1012 to interact with the computer system 1020 and/or one or more communications devices to enable a system user 1012 to communicate with the computer system 1020 using any type of communications link. To this extent, the computer system 1020 may manage a set of interfaces (e.g., graphical user interface(s), application program interface, and/or the like) that enable human and/or system users 1012 to interact with the software executing thereon, such as the functional modeling interface 1030. Furthermore, the functional modeling interface 1030 may cause the computer system 1020 to manage (e.g., store, retrieve, create, manipulate, organize, present, or the like) the data, such as one or more functional model-based applications 1036, using any data management solution.

In any event, the computer system 1020 may comprise one or more general purpose computing articles of manufacture (e.g., computing devices) capable of executing program code installed thereon. As used herein, it is understood that “program code” means any collection of instructions, in any language, code or notation, that cause a computing device having an information processing capability to perform a particular function either directly or after any combination of the following: (a) conversion to another language, code or notation; (b) reproduction in a different material form; and/or (c) decompression.

As used herein, the term “component” means any configuration of hardware, with or without software, which implements the functionality described in conjunction therewith using any solution. The term “module” means program code that enables a computer system 1020 to implement the functionality described in conjunction therewith using any solution. When fixed in a storage component 1024 of a computer system 1020 that includes a processing component 1022, a module is a substantial portion of a component that implements the functionality. Regardless, it is understood that two or more components, modules, and/or systems may share some/all of their respective hardware and/or software. Furthermore, it is understood that some of the functionality discussed herein may not be implemented or additional functionality may be included as part of the computer system 1020.

When the computer system 1020 comprises multiple computing devices, each computing device may have only a portion of a software application, such as the functional modeling interface 1030 and/or the functional model-based application 1036, fixed thereon (e.g., one or more function models 1038 of the application 1036). However, it is understood that the computer system 1020 and program code (e.g., a software application) are only representative of various possible equivalent computer systems that may perform a process described herein. To this extent, in other embodiments, the functionality provided by the computer system 1020 and program code executing thereon can be at least partially implemented by one or more computing devices that include any combination of general and/or specific purpose hardware with or without program code. In each embodiment, the hardware and program code, if included, can be created using standard engineering and programming techniques, respectively.

Regardless, when the computer system 1020 includes multiple computing devices, the computing devices may communicate over any type of communications link. Furthermore, while performing a process described herein, the computer system 1020 may communicate with one or more other computer systems using any type of communications link. In either case, the communications link may comprise any combination of various types of wired and/or wireless links; comprise any combination of one or more types of networks; and/or utilize any combination of various types of transmission techniques and protocols. In an embodiment, the computer system 1020 comprises an application server, which communicates with users 1012 over the Internet.

As discussed herein, the functional model-based application 1036 may be represented by a set of function models 1038. Each function model 1038 may define a function as a set of hardware-independent actions. A function model 1038 may reference one or more micro-functions 1034, which can be made available for use in defining the functional model-based application 1036 in a distributed operating system 1032. To this extent, the functional modeling interface 1030 may provide an interface that enables a user 1012 to define, modify, and/or the like, a function model 1038 by selecting one or more micro-functions 1034 and defining the corresponding conditions, criteria, chain, and/or the like, as described herein.

When desired, the user 1012 may deploy the functional model-based application 1036 for execution in a target computing environment 1010. As part of the deployment process, the functional model-based application 1036 may be converted into an executable application by a set of nodes, such as the computer system 1020, in the target computing environment having a distributed operating system 1032. In particular, the set of nodes in the target computing environment can comprise a distributed operating system 1032, which includes one or more agents 1033, which are configured to process the function model(s) 1038 of the application 1036. Such processing can utilize the micro-functions 1034 to convert device-independent references for the corresponding micro-functions into implementations of the micro-functions capable of performing the corresponding micro-function within the target computing environment as contextualized micro-capabilities 1010. The micro-functions 1034 may provide the functional model-based application 1036 with unified access and usage of resources independent of their embodiment. As discussed herein, such a conversion may occur in real-time during execution of the functional model-based application 1036, thereby enabling the execution of the functional model-based application 1036 to be highly responsive to changes to the target computing environment.

The computing environment 1010 may include a fabric of interconnected computing resources, which includes computer system 1020 as well as one or more additional computer systems 1021A, 1021B. Each computer system 1021A, 1021B can be configured similar to the computer system 1020, although a computer system 1021A, 1021B may not include a functional modeling interface 1030 and/or a distributed operating system 1032. As illustrated, each of the computer systems 1020, 1021A, 1021B may communicate with each other using any solution. When a functional model-based application 1036 is deployed to the computing environment 1010, the computer system 1020 may utilize one or more resources of another computer system 1021A, 1021B to execute the functional model-based application 1036. Such utilization can include providing at least a portion of the functional model-based application 1036 for execution on the computer system 1021A, 1021B (e.g., when the computer system 1021A, 1021B includes a distributed operating system 1032).

As described herein, some embodiments may address significant issues with respect to the design, development, and deployment of software applications. In particular, some embodiments can allow a user to design and deploy an application using a functional modeling solution, such that the application is not restricted to execution in any particular target computing environment. Additionally, some embodiments can address significant issued regarding the execution of applications in distributed computing environments. In particular, as the amount and/or types of resources available in these computing environments can be frequently changed, binding of the software application to a particular configuration of computing resources can be delayed until such binding is required during execution of the application.

Various Embodiments

While shown and described herein as a method and system for managing (e.g., designing, constructing, deploying, using, and modifying) software applications on a plurality of computing resources, which can operate collaboratively and in parallel, it is understood that various alternative or additional embodiments may be provided. For example, in various embodiments, a computer program is fixed in at least one computer-readable medium, which when executed, enables a computer system to manage software applications on a plurality of computing resources. To this extent, the computer-readable medium includes program code, which enables a computer system to implement some or all of a process described herein. It is understood that the term “computer-readable medium” comprises one or more of any type of tangible medium of expression, now known or later developed, from which a copy of the program code can be perceived, reproduced, or otherwise communicated by a computing device. For example, the computer-readable medium can comprise: one or more portable storage articles of manufacture; one or more memory/storage components of a computing device; paper; and/or the like.

In another embodiment, a method provides a copy of program code, which enables a computer system to implement some or all of a process described herein. In this case, a computer system may process a copy of the program code to generate and transmit, for reception at a second, distinct location, a set of data signals that has one or more of its characteristics set and/or changed in such a manner as to encode a copy of the program code in the set of data signals. Similarly, some embodiments provide a method of acquiring a copy of the program code, which includes a computer system receiving the set of data signals described herein, and translating the set of data signals into a copy of the computer program fixed in at least one computer-readable medium. In either case, the set of data signals can be transmitted/received using any type of communications link.

In still another example, a method provides generating a system for managing software applications on a plurality of computing resources. In this case, the generating may include configuring a computer system, such as the computer system 1020 (FIG. 10 ), to implement a method of managing software applications on a plurality of computing resources. The configuring may include obtaining (e.g., creating, maintaining, purchasing, modifying, using, making available, or the like) one or more hardware components, with or without one or more software modules, and setting up the components and/or modules to implement a process described herein. To this extent, the configuring can include deploying one or more components to the computer system, which can comprise one or more of: (1) installing program code on a computing device; (2) adding one or more computing and/or I/O devices to the computer system; (3) incorporating and/or modifying the computer system to enable it to perform a process described herein; and/or the like.

The present invention(s) are described above with reference to example embodiments. It will be appreciated that various modifications may be made and other embodiments may be used without departing from the broader scope of the present invention(s). Therefore, these and other variations upon the example embodiments are intended to be covered by the present invention(s). 

What is claimed is:
 1. A system comprising: a memory; at least one processor coupled to the memory and configured to: detect a real-time system request; determine a context and metadata based on the real-time system request; fetch an application model that references a micro-function based on the context and the metadata; transform the micro-function into a micro-capability by determining a computing resource to execute the micro-capability by matching a parameter of the micro-capability; configure the micro-capability on the computing resource by providing access in a target environment to an interface, the interface capable of calling the micro-capability to execute the micro-capability on the computing resource; and providing an output of the micro-capability from the computing resource to the target environment.
 2. The system of claim 1, wherein the real-time system request indicates an application object in a header.
 3. The system of claim 2, wherein the context includes an identifier indicating the application object.
 4. The system of claim 3, wherein the output of the micro-capability comprises a customized representation of the application object.
 5. The system of claim 1, wherein the application model, the micro-function, the micro-capability, and the computing resource are modeled from a root object defining base properties and capabilities.
 6. The system of claim 1, further comprising a plurality of computing resources, wherein the plurality of computing resources includes the computing resource, wherein the plurality of computing resources provide a virtualized pool of resources, and wherein each of the plurality of computing resources are a virtualized infrastructure, a physical infrastructure, or a software-controlled device.
 7. The system of claim 6, wherein the plurality of computing resources are distributed across a multi-dimensional network of nodes connected by one or more links.
 8. The system of claim 1, wherein the computing resource comprises one or more computing resource descriptors that include an API descriptor associated with the interface.
 9. The system of claim 8, wherein the one or more computing resource descriptors comprise any of one or more local interfaces, local capabilities, local services, supporting services, and operating system kernels.
 10. The system of claim 8, wherein the one or more computing resource descriptors facilitate management of thread handling, resources, and memory spaces for the computing resource for a singular virtual infrastructure unit, physical infrastructure unit, or software-controlled device.
 11. A method, comprising: detecting, by one or more processors, a real-time system request; determining a context and metadata based on the real-time system request; fetching an application model that references a micro-function based on the context and the metadata; transforming the micro-function into a micro-capability by determining a computing resource to execute the micro-capability by matching a parameter of the micro-capability; configuring the micro-capability on the computing resource by providing access in a target environment to an interface, the interface capable of calling the micro-capability to configure and execute the micro-capability on the computing resource; and providing an output of the micro-capability from the computing resource to the target environment.
 12. The method of claim 11, wherein the real time system request indicates an application object in a header.
 13. The method of claim 12, wherein the context includes an identifier indicating the application object.
 14. The method of claim 13, wherein the output of the micro-capability comprises a customized representation of the application object.
 15. The method of claim 11, wherein the application model, the micro-function, the micro-capability, and the computing resource are modeled from a root object defining base properties and capabilities.
 16. The method of claim 11, further comprising a plurality of computing resources, wherein the plurality of computing resources includes the computing resource, wherein the plurality of computing resources provide a virtualized pool of resources, and wherein each of the plurality of computing resources are a virtualized infrastructure, a physical infrastructure, or a software-controlled device.
 17. The method of claim 16, wherein the plurality of computing resources are distributed across a multi-dimensional network of nodes connected by one or more links.
 18. The method of claim 11, wherein the computing resource comprises one or more computing resource descriptors that include an API descriptor associated with the interface.
 19. The method of claim 18, wherein the one or more computing resource descriptors comprise any of one or more local interfaces, local capabilities, local services, supporting services, and operating system kernels.
 20. A non-transitory computer-readable device having instructions stored thereon that, when executed by at least one computing device, causes the at least one computing device to perform operations comprising: detecting, by one or more processors, a real-time system request; determining a context and metadata based on the real-time system request; fetching an application model that references a micro-function based on the context and the metadata; transforming the micro-function into a micro-capability by determining a computing resource to execute the micro-capability by matching a parameter of the micro-capability; configuring the micro-capability on the computing resource by providing access in a target environment to an interface, the interface capable of calling the micro-capability to configure and execute the micro-capability on the computing resource; and providing an output of the micro-capability from the computing resource to the target environment. 